#pragma once

#include <memory>
#include <string>
#include <vector>

#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <ros/serialization.h>
#include <ros/types.h>
#include <actionlib_msgs/GoalID.h>
#include <std_msgs/Header.h>

#include "@PROTO_H@Goal.h"

namespace @Package@ {
    typedef boost::shared_ptr<@Package@::@PROTO_H@Goal> @PROTO_H@GoalPtr;
    typedef boost::shared_ptr<@Package@::@PROTO_H@Goal const> @PROTO_H@GoalConstPtr;

    template <class ContainerAllocator>
    struct @Class@_ {
        typedef @Class@_<ContainerAllocator> Type;

        @Class@_() : header(), goal_id(), goal() {
        }
        @Class@_(const ContainerAllocator &_alloc) : header(_alloc), goal_id(_alloc), goal(_alloc) {
            (void)_alloc;
        }

        typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
        _header_type header;

        typedef ::actionlib_msgs::GoalID_<ContainerAllocator> _goal_id_type;
        _goal_id_type goal_id;

        typedef @Package@::@PROTO_H@Goal _goal_type;
        _goal_type goal;

        typedef boost::shared_ptr<::@Package@::@Class@_<ContainerAllocator>> Ptr;
        typedef boost::shared_ptr<::@Package@::@Class@_<ContainerAllocator> const> ConstPtr;
    }; // struct @Class@_

    typedef ::@Package@::@Class@_<std::allocator<void>> @Class@;

    typedef boost::shared_ptr<::@Package@::@Class@> @Class@Ptr;
    typedef boost::shared_ptr<::@Package@::@Class@ const> @Class@ConstPtr;

    template <typename ContainerAllocator>
    std::ostream &operator<<(std::ostream &s, const ::@Package@::@Class@_<ContainerAllocator> &v) {
        ros::message_operations::Printer<::@Package@::@Class@_<ContainerAllocator>>::stream(s, "", v);
        return s;
    }
} // namespace @Package@

namespace ros { namespace message_traits {
    template <class ContainerAllocator>
    struct MD5Sum<::@Package@::@Class@_<ContainerAllocator>> {
        static const char *value() {
            return "@Checksum@";
        }

        static const char *value(const ::@Package@::@Class@_<ContainerAllocator> &) {
            return value();
        }
    };

    template <class ContainerAllocator>
    struct DataType<::@Package@::@Class@_<ContainerAllocator>> {
        static const char *value() {
            return "@Package@/@Class@";
        }

        static const char *value(const ::@Package@::@Class@_<ContainerAllocator> &) {
            return value();
        }
    };

    template <class ContainerAllocator>
    struct Definition<::@Package@::@Class@_<ContainerAllocator>> {
        static const char *value() {
            return "@Package@/@Class@";
        }

        static const char *value(const ::@Package@::@Class@_<ContainerAllocator> &) {
            return value();
        }
    };
}} // namespace ros::message_traits

namespace ros { namespace serialization {
    template <class ContainerAllocator>
    struct Serializer<::@Package@::@Class@_<ContainerAllocator>> {
        template <typename Stream, typename T>
        inline static void allInOne(Stream &stream, T m) {
            stream.next(m.header);
            stream.next(m.goal_id);
            stream.next(m.goal);
        }

        ROS_DECLARE_ALLINONE_SERIALIZER
    }; // struct @Class@_
}} // namespace ros::serialization